Hvordan sletter jeg en Git-filial lokalt og eksternt?

1
2
Næste
Resumé
$ git push -d  
$ git filial -d 
Bemærk, at fjernnavnet i de fleste tilfælde er oprindelse.
I et sådant tilfælde bliver du nødt til at bruge kommandoen sådan.
$ git push -d oprindelse 
Slet lokal filial
For at slette den lokale filial skal du bruge et af følgende:
$ git gren -d filialnavn
$ git filial -D filialnavn
Bemærk: Indstillingen -d er et alias for --delete, som kun sletter grenen, hvis den allerede er fuldstændigt flettet i sin upstream-gren. Du kan også bruge -D, som er et alias for --delete --force, som sletter grenen "uanset dens fusionerede status." [Kilde: man git-branch]
Bemærk også, at git branch -d branch_name mislykkes, hvis du er i øjeblikket
i den gren, du vil fjerne. Meddelelsen starter med
fejl: Kan ikke slette grenen 'filialnavn'. Skift i så fald først
til en anden gren, for eksempel: git checkout master.
Slet Remote Branch [Opdateret den 8.-september-2017]
Fra og med Git v1.7.0 kan du slette en ekstern gren ved hjælp af
$ git push  - slet 
som måske er lettere at huske end
$ git push : 
som blev tilføjet i Git v1.5.0 "for at slette en ekstern gren eller et tag."
Fra og med Git v2.8.0 kan du også bruge git push med -d-indstillingen som et alias til --delete.
Derfor vil den version af Git, du har installeret, diktere, om du har brug for den lettere eller hårdere syntaks.
Slet fjernforgrening [Originalt svar fra 5. januar 2010]
Fra kapitel 3 i Pro Git af Scott Chacon:
Sletning af eksterne grene
Antag, at du er færdig med en fjernfilial - sig, at du og dine samarbejdspartnere er færdige med en funktion og har flettet den ind i fjernbetjeningens hovedfilial (eller hvilken gren som din stabile kodelinje er i). Du kan slette en ekstern gren ved hjælp af den temmelig stumpe syntaks git push [fjernnavn]: [gren]. Hvis du vil slette din serverrettelsesfilial fra serveren, kører du følgende:
$ git push-oprindelse: serverfix
Til git@github.com: schacon / simplegit.git
- [slettet] serverfix
Boom. Ingen flere filialer på din server. Du vil måske øre denne side, fordi du har brug for den kommando, og du vil sandsynligvis glemme syntaksen. En måde at huske denne kommando på er ved at huske git push [remotename] [localbranch]: [remotebranch] syntaks, som vi gik lidt over tidligere. Hvis du holder op med [localbranch] -delen, siger du dybest set: "Tag intet på min side, og gør det til [remotebranch]."
Jeg udstedte git push-oprindelse: bugfix, og det fungerede smukt. Scott Chacon havde ret - jeg vil gerne øre den side (eller næsten hundeøret ved at besvare dette på Stack Overflow).
Så skal du udføre dette på andre maskiner
# Hent ændringer fra alle fjernbetjeninger og slet lokalt
# fjern slettede grene / tags osv
# --beskær vil gøre jobbet: -;
git-hentning - alt - beskær
at udbrede ændringer.
|
Matthews svar er fantastisk til at fjerne fjerntliggende grene, og jeg sætter også pris på forklaringen, men for at gøre en simpel skelnen mellem de to kommandoer:
Sådan fjerner du en lokal filial fra din maskine:
git branch -d {the_local_branch} (brug -D i stedet for at tvinge sletning af filialen uden at kontrollere flettet status)
Sådan fjernes en ekstern gren fra serveren:
git push-oprindelse - slet {the_remote_branch}
Reference: Git: Slet en filial (lokal eller ekstern)
|
De korte svar
Hvis du vil have mere detaljerede forklaringer på følgende kommandoer, skal du se de lange svar i næste afsnit.
Sletning af en ekstern gren
git push origin --delete  # Git version 1.7.0 eller nyere
git push origin -d  # Kortere version (Git 1.7.0 eller nyere)
git push-oprindelse:  # Git-versioner ældre end 1.7.0
Sletning af en lokal filial
git branch --delete 
git branch -d  # Kortere version
git branch -D  # Tving-slet ikke-flettede grene
Sletning af en lokal fjernsporingsfilial
git gren --delete - fjernbetjeninger  / 
git gren -dr  /  # Kortere
git hente  - beskære # Slet flere forældede fjernsporingsgrene
git hent  -p # kortere
Det lange svar: der er tre forskellige grene at slette!
Når du har at gøre med at slette filialer både lokalt og eksternt, skal du huske at der er tre forskellige grene involveret:
Den lokale filial X.
Den fjerne oprindelsesfilial X.
Den lokale fjernsporende grenens oprindelse / X, der sporer den eksterne gren X.
Den originale plakat, der blev brugt:
git gren -rd oprindelse / bugfix
Som kun slettede hans lokale fjernsporende filialoprindelse / bugfix, og ikke den egentlige fjernfilialfejlfiks på oprindelse.
For at slette den aktuelle fjernfilial skal du have
git push-oprindelse - slet bugfix
Yderligere detaljer
De følgende sektioner beskriver yderligere detaljer, der skal overvejes, når du sletter dine grene til fjernbetjening og fjernsporing.
Ved at skubbe for at slette fjerntliggende grene fjernes også fjernsporende grene
Bemærk, at sletning af den eksterne gren X fra kommandolinjenved hjælp af et git-skub fjernes også den lokale fjernsporingsgrenens oprindelse / X, så det er ikke nødvendigt at beskære den forældede fjernsporingsgren med git-hentning - beskæring eller git-hentning -p. Det ville dog ikke skade, hvis du alligevel gjorde det.
Du kan kontrollere, at fjernsporing af filialens oprindelse / X også blev slettet ved at køre følgende:
# Se bare fjernsporing af grene
git gren - fjernbetjeninger
git gren -r
# Se både strengt lokale såvel som fjernsporende grene
git gren - alt
git gren -a
Beskæring af den forældede lokale fjernsporing af grenens oprindelse / X
Hvis du ikke slettede din fjerngren X fra kommandolinjen (som ovenfor), vil dit lokale arkiv stadig indeholde (en nu forældet) fjernsporing af grenens oprindelse / X. Dette kan ske, hvis du f.eks. Har slettet en ekstern gren direkte gennem GitHubs webgrænseflade.
En typisk måde at fjerne disse forældede fjernsporingsgrene på (siden Git version 1.6.6) er simpelthen at køre git-hentning med --prune eller kortere -p. Bemærk, at dette fjerner alle forældede lokale fjernsporingsgrene for eventuelle eksterne grene, der ikke længere findes på fjernbetjeningen:
git hent oprindelse - beskær
git hente oprindelse -p # Kortere
Her er det relevante citat fra 1.6.6-udgivelsesnoterne (min vægt):
"git fetch" lærte - alle og - flere valg, at køre hentning fra
mange arkiver og --prune mulighed for at fjerne fjernsporing
grene, der blev forældede. Disse gør "git remote update" og "git
fjernbeskæring "mindre nødvendigt (der er ingen plan om at fjerne" fjernbetjening
opdater "eller" fjern beskæring ", dog).
Alternativ til ovenstående automatisk beskæring til forældede fjernsporingsgrene
Alternativt kan du i stedet for at beskære dine forældede lokale fjernsporingsgrene gennem git fetch -p, undgå at udføre den ekstra netværkshandling ved blot manuelt at fjerne grenen (e) med flagene --remote eller -r:
git gren - slet - fjern oprindelse / X
git branch -dr origin / X # Shorter
Se også
git-branch (1) Manual Side.
git-fetch (1) Manuel side.
Pro Git § 3.5 Git-forgrening - fjerntliggende grene.
|
Trin til sletning af en gren:
For at slette den eksterne gren:
git push-oprindelse - slet 
For at slette den lokale filial har du tre måder:
1: git gren -D 
2: git branch --delete --force  # Samme som -D
3: git branch --delete  # Fejl ved fletning
Forklar: OK, forklar bare hvad der foregår her!
Du skal blot git push-oprindelse - slet kun for at slette din fjerntliggende gren, tilføj filialens navn i slutningen, og dette slettes og skubber det til fjernbetjening på samme tid ...
Også git gren -D, som kun sletter den lokale filial! ...
-D står for --delete - force, der sletter grenen, selvom den ikke er flettet (tvangssletning), men du kan også bruge -d, som står for --delete, som kaster en fejl i henhold til grenens fletningsstatus ...
Jeg opretter også billedet nedenfor for at vise trinnene:
|
Du kan også bruge følgende til at slette den eksterne gren
git push - slet oprindelse serverfix
Hvilket gør det samme som
git push-oprindelse: serverfix
men det kan være lettere at huske.
|
Tip: Når du sletter grene ved hjælp af
git branch -d  # Sletter lokal filial
eller
git push-oprindelse:  # Sletter fjernfilial
kun referencerne slettes. Selvom filialen faktisk fjernes på fjernbetjeningen, findes referencerne til den stadig i dine teammedlemmers lokale opbevaringssteder. Dette betyder, at for andre teammedlemmer er de slettede grene stadig synlige, når de laver en git-gren -a.
For at løse dette kan dine teammedlemmer beskære de slettede grene med
git fjernbetjent beskæring 
Dette er typisk git fjern beskærespring.
|
Hvis du vil slette en gren, skal du først tjekke til den anden gren end den gren, der skal slettes.
git checkout andet_dan_filial_til_be_slettet
Sletning af den lokale filial:
git branch -D branch_to_be_deleted
Sletning af den eksterne gren:
git push origin - slet branch_to_be_deleted
|
git gren -D 
git gren -D -r oprindelse / 
git push-oprindelse: 
|
Dette er simpelt: Kør bare følgende kommando:
For at slette en Git-gren både lokalt og eksternt skal du først slette den lokale filial ved hjælp af denne kommando:
git gren -d eksempel
(Her er eksemplet grenens navn.)
Og derefter sletter du den eksterne gren ved hjælp af denne kommando:
git push-oprindelse: eksempel
|
Det er meget simpelt:
For at slette den eksterne gren
git push -d oprindelse 
Eller
git push-oprindelse: 
For at slette den lokale filial kraftigt
git branch -D 
|
En anden tilgang er:
git push - beskær oprindelse
ADVARSEL: Dette sletter alle eksterne grene, der ikke findes lokalt. Eller mere omfattende,
git push - spejl
vil effektivt få fjernlageret til at ligne den lokale kopi af lageret (lokale hoveder, fjernbetjeninger og tags spejles på fjernbetjeningen).
|
Jeg bruger følgende i mine Bash-indstillinger:
alias git-shoot = "git pushoprindelse - slet "
Så kan du ringe:
git-shoot grennavn
|
Slet lokalt:
For at slette en lokal filial kan du bruge:
git branch -d 
For at slette en gren med magt skal du bruge -D i stedet for -d.
git gren -D 
Slet eksternt:
Der er to muligheder:
git push-oprindelse: filialnavn
git push-oprindelse - slet filialnavn
Jeg vil foreslå, at du bruger den anden måde, da den er mere intuitiv.
|
Siden januar 2013 inkluderede GitHub en Slet gren-knap ved siden af ​​hver gren på din "Branches" -side.
Relevant blogindlæg: Opret og slet grene
|
Hvis du vil gennemføre begge disse trin med en enkelt kommando, kan du oprette et alias for det ved at tilføje nedenstående til din ~ / .gitconfig:
[alias]
rmbranch = "! f () {git branch -d $ {1} && git push origin - slet $ {1};}; f"
Alternativt kan du tilføje dette til din globale konfiguration fra kommandolinjen ved hjælp af
git config - globalt alias.rmbranch \
'! f () {git branch -d $ {1} && git push origin - slet $ {1}; }; f '
BEMÆRK: Hvis du bruger -d (små bogstaver d), slettes grenen kun, hvis den er blevet flettet. For at tvinge sletningen til at ske skal du bruge -D (store bogstaver D).
|
For at slette din filial lokalt og eksternt
Checkout til masterfilial - git checkout master
Slet din eksterne filial - git push origin - slet 
Slet din lokale filial - git gren - slet 
|
Du kan også gøre dette ved hjælp af git remote beskære oprindelse
$ git fjern beskærespring
Beskæring af oprindelse
URL: git@example.com/yourrepo.git
* [beskåret] oprindelse / nogle grene
Det beskærer og sletter fjernsporende grene fra en git gren -r liste.
|
Ud over de andre svar bruger jeg ofte værktøjet git_remote_branch. Det er en ekstra installation, men det giver dig en bekvem måde at interagere med eksterne grene. I dette tilfælde skal du slette:
grb slette gren
Jeg finder ud af, at jeg også bruger udgivelses- og sporkommandoer ganske ofte.
|
En one-liner-kommando til at slette både lokal og fjernbetjening:
D = gren-navn; git gren -D $ D; git push-oprindelse: $ D
Eller tilføj aliaset nedenfor til din ~ / .gitconfig. Anvendelse: git kill gren-navn
[alias]
kill = "! f () {git branch -D \" $ 1 \ "; git push origin - slet \" $ 1 \ ";}; f"
|
Sletning af filialer
Lad os antage, at vores arbejde med filialens "kontaktformular" er udført, og vi har allerede integreret det i "master". Da vi ikke har brug for det længere, kan vi slette det (lokalt):
$ git filial -d kontaktformular
Og til sletning af den eksterne gren:
git push origin - slet kontaktformular
|
Slet fjernfilial
git push-oprindelse: 
Slet lokal filial
git branch -D 
Slet lokale filialtrin:
kassen til en anden filial
slet lokal filial
|
Sig blot:
git branch -d 
git push-oprindelse: 
|
git push origin --delete 
er lettere at huske end
git push origin: branchName
|
Nu kan du gøre det med GitHub Desktop-applikationen.
Efter start af applikationen
Klik på det projekt, der indeholder filialen
Skift til den gren, du vil slette
Fra menuen "Branch" skal du vælge "Unpublish ..." for at få grenen slettet fra GitHub-serverne.
Fra menuen "Filial" skal du vælge "Slet" filialnavn "..." for at få filialen slettet fra din lokale maskine (AKA den maskine, du i øjeblikket arbejder på)
|
Sådan slettes lokalt - (normal)
git gren -d my_branch
Hvis din filial er i en omstarts- / sammensmeltningsfremgang, og det ikke blev gjort ordentligt, betyder det, at du får en fejl, Rebase / Fletning er i gang, så i så fald vil du ikke være i stand til at slette din gren.
Så enten skal du løse rebasing / fletning. Ellers kan du tvinge sletning ved hjælp af,
git gren -D my_branch
Sådan slettes i fjernbetjeningen:
git push - slet oprindelse my_branch
Du kan gøre det samme ved hjælp af:
git push origin: my_branch # Let at huske, begge gør det samme.
Grafisk gengivelse:
|
Dette fungerer ikke, hvis du har et tag med samme navn som filialen på fjernbetjeningen:
$ git push-oprindelse: gren-eller-tag-navn
fejl: dst refspec gren-eller-tag-navn matcher mere end en.
fejl: kunne ikke skubbe nogle refs til 'git@github.com: SomeName / some-repo.git'
I så fald skal du angive, at du vil slette grenen, ikke taggen:
git push-oprindelse: refs / heads / branch-or-tag-name
Tilsvarende skal du slette koden i stedet for den gren, du bruger:
git push origin: refs / tags / branch-or-tag-name
|
Mange af de andre svar vil føre til fejl / advarsler. Denne tilgang er relativt idiotsikker, selvom du muligvis stadig har brug for git branch -D branch_to_delete, hvis den ikke er fusioneret fuldt ud i f.eks. Some_other_branch.
git checkout some_other_branch
git push-oprindelse: branch_to_delete
git branch -d branch_to_delete
Fjernbeskæring er ikke nødvendig, hvis du slettede den eksterne gren. Det bruges kun til at få de mest opdaterede fjernbetjeninger til rådighed på et lager, du sporer. Jeg har observeret, at git-hentning tilføjer fjernbetjeninger, ikke fjerner dem. Her er et eksempel på, hvornår git remote beskære oprindelse faktisk vil gøre noget:
Bruger Agør ovenstående trin. Bruger B kører følgende kommandoer for at se de mest opdaterede eksterne grene:
git-hentning
git fjern beskæring oprindelse
git gren -r
|
Jeg blev træt af at google for dette svar, så jeg tog en lignende tilgang til det svar, som crizCraig postede tidligere.
Jeg tilføjede følgende til min Bash-profil:
funktion gitdelete () {
git push-oprindelse - slet $ 1
git gren -D $ 1
}
Så hver gang jeg er færdig med en filial (fx fusioneret til master), kører jeg følgende i min terminal:
gitdelete my-branch-name
... som derefter sletter mit gren-navn fra oprindelse såvel som lokalt.
|
Før udførelse
git branch --delete 
Sørg for, at du først bestemmer, hvad det nøjagtige navn på den eksterne gren er ved at udføre:
git ls-fjernbetjening
Dette fortæller dig, hvad du skal indtaste nøjagtigt for  -værdien. (gren er skift mellem store og små bogstaver!)
|
Brug:
git push origin: bugfix # Sletter fjerntliggende gren
git branch -d bugfix # Skal slette lokal gren manuelt
Hvis du er sikker på, at du vil slette det, skal du køre
git gren -D bugfix
Nu for at rydde op slettede fjerntliggende grene kører
git fjern beskæring oprindelse
|
1
2
Næste
Meget aktivt spørgsmål. Optjen 10 omdømme for at besvare dette spørgsmål. Omdømmekravet hjælper med at beskytte dette spørgsmål mod spam og ikke-svar-aktivitet.
Er det ikke det svar, du leder efter? Gennemse andre spørgsmål mærket git version-control git-branch git-push git-fjernbetjening eller stil dit eget spørgsmål.